home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / sos3-2.lha / src / agg / Bag.c < prev    next >
C/C++ Source or Header  |  1992-01-23  |  28KB  |  789 lines
  1. /* --------------------------------------------------------------------------
  2.  * Copyright 1992 by Forschungszentrum Informatik (FZI)
  3.  *
  4.  * You can use and distribute this software under the terms of the licence
  5.  * you should have received along with this program.
  6.  * If not or if you want additional information, write to
  7.  * Forschungszentrum Informatik, "STONE", Haid-und-Neu-Strasse 10-14,
  8.  * D-7500 Karlsruhe 1, Germany.
  9.  * --------------------------------------------------------------------------
  10.  */
  11. // **************************************************************************
  12. // Module Bag                       03/07/89           Bernhard Schiefer (bs)
  13. //                                                    modified:   9/8/90 (ja)
  14. //                                                              24/10/91 (bs)
  15. // **************************************************************************
  16. // implements methods of classes: Bag
  17. // **************************************************************************
  18.  
  19. #include "agg_err.h"
  20. #include "trc_agg.h"
  21. #include "sys.h"
  22.  
  23. #include "agg_sos.h"
  24.  
  25. /*
  26. Ein Bag ist eine Erweiterung von Set, eingetragene Objekte koennen auch in 
  27. mehrfachen Exemplaren eingetragen werden.
  28. Die Implementierung setzt auf einem Mapping auf, und zwar wird eine Abbildung
  29. von einem Objekt auf eine Zahl benutzt. Die Zahl gibt die Anzahl an, wieviel 
  30. Exemplare dieses Objekts im Bag sind. Die Moeglichkeit im Schema ein 
  31. Object_sos_Int_Mapping zu benutzen wurde verworfen, stattdessen wird das
  32. ordinaere Mapping benutzt, wobei ein Entity als Zahl sos_Interpretiert wird.
  33. Der Container liegt nutzlos auf der Platte.
  34. */
  35.  
  36. // **************************************************************************
  37. void sos_Object_Bag::search_succ_pred (sos_Bag_node bn,  Index steps, 
  38.                        sos_Object& o, sos_Int& no, sos_Int& max)
  39. // **************************************************************************
  40. // suche ausgehend von dem Element in bag_node steps Schritte nach vorne
  41. // bzw. hsos_Inten. Liefere in o,no,max die neue Position. Ist die 
  42. // Position nicht gueltig, so ist o = my_no_object
  43. {
  44.    sos_Object_sos_Int_Mapping m = self.get_m();
  45.    sos_Cursor cur = m.open_cursor();
  46.  
  47.    max = bn.get_tag_max();
  48.    no = bn.get_tag_no();
  49.    o = bn.get_key_val();
  50.    sos_Object my_no_object = m;
  51.  
  52.    m.move_cursor (cur, o);
  53.  
  54.    for (;o != my_no_object AND steps != 0; )
  55.    {  if (steps > 0)
  56.       {  // Muss ich aufs naechste Element gehen ?
  57.          if (no+steps > max)
  58.          {  // Ja
  59.             if (m.to_succ (cur))
  60.             {  o = m.get_key (cur);
  61.                steps -= (max-no+1);
  62.                no = 1;
  63.                max =  m.get_info (cur);
  64.             }
  65.             else
  66.                o = my_no_object; 
  67.          }
  68.          else
  69.          {  // Nein
  70.             no += steps;
  71.             steps = 0;
  72.          }
  73.       }
  74.       else
  75.       {  // muss ich aufs fruehere Element gehen ?
  76.          if (steps+no < 1)
  77.          {  // Ja
  78.             if (m.to_pred (cur))
  79.             {  o = m.get_key (cur);
  80.                steps += no;
  81.                max = m.get_info (cur);
  82.                no = max;
  83.             }
  84.             else
  85.                o = my_no_object; 
  86.             // Im Augenblick steht der Zeiger auf der letzten 
  87.             // Auspraegung des Objects
  88.          }
  89.          else
  90.          {  // Nein
  91.             no += steps;
  92.             steps = 0;
  93.          }
  94.       }
  95.    } // for
  96. } // sos_Object_Bag::search_succ_pred
  97.  
  98.  
  99. // **************************************************************************
  100. void sos_Object_Bag::write_current (sos_Cursor c,
  101.                                     sos_Object o,
  102.                                     sos_Int    no,
  103.                                     sos_Int    max)
  104. // **************************************************************************
  105. // schreibe in den Cursor die Position auf dem sos_Object o,
  106. // der Exemplarnummer no und der Exemplaranzahl max.
  107. {
  108.    sos_Bag_node               bn = sos_Bag_node::make (c.get_current());
  109.    sos_Object_sos_Int_Mapping m  = self.get_m();
  110.  
  111.    bn.set_key_val (o);
  112.    bn.set_tag_no (no);
  113.    bn.set_tag_max (max);
  114. } // sos_Object_Bag::write_current
  115.  
  116. // **************************************************************************
  117. sos_Int sos_Object_Bag::get_no_of_elements (sos_Object_sos_Int_Mapping m,
  118.                                             sos_Object                 o)
  119. // **************************************************************************
  120. // liefert die Anzahl der Vorkommen, die im Mapping m vom Objekt o sind
  121. {
  122.    if (m.is_key (o))
  123.       return m[o];
  124.    else
  125.       return 0;
  126. } // ** sos_Object_Bag::get_no_of_element
  127.  
  128. // **************************************************************************
  129. sos_Int sos_Object_Bag::set_no_of_elements (sos_Object_sos_Int_Mapping m,
  130.                                             sos_Object o,
  131.                                             sos_Int old_no,
  132.                                             sos_Int new_no)
  133. // **************************************************************************
  134. // Setzt die Anzahl der Vorkommen von o von vormals old_no auf new_no
  135. // Es wird die Anzahl zurueckgeliefert, die dazukam
  136. {
  137.    if ((new_no == 0) AND (old_no >0))
  138.    {
  139.      m.remove (o);
  140.      return -old_no;
  141.    }
  142.    else
  143.       // Hier ist new_no>0 oder old_no==0
  144.       if ((new_no > 0) AND (old_no != new_no))
  145.       {
  146.          m.insert (o, new_no);
  147.          return new_no - old_no;
  148.       }
  149.       else 
  150.       // Hier ist old_no==new_no => nichts
  151.          return 0;
  152. } //  ** sos_Object_Bag::set_no_of_elements
  153.  
  154.  
  155. // **************************************************************************
  156. void sos_Object_Bag::local_initialize (sos_Object_Bag bag)
  157. // **************************************************************************
  158. {  T_PROC ("sos_Object_Bag::local_initialize");
  159.    TT (agg_H, T_ENTER);
  160.  
  161.    bag.set_cardinality (0);
  162.    bag.set_m (sos_Object_sos_Int_Mapping::create
  163.           (bag.container(),
  164.            bag.get_list_cursor(),
  165.            bag.get_based_on_equal()));
  166.  
  167.    TT (agg_H, T_LEAVE);
  168. } // ** local_initialize **
  169.  
  170. // **************************************************************************
  171. void sos_Object_Bag::local_finalize (sos_Object_Bag bag)
  172. // **************************************************************************
  173. {  T_PROC ("sos_Object_Bag::local_finalize");
  174.    TT (agg_H, T_ENTER);
  175.  
  176.    bag.get_m().destroy();
  177.  
  178.    TT (agg_H, T_LEAVE);
  179. } // ** local_finalize **
  180.  
  181. // **************************************************************************
  182. sos_Int sos_Object_Bag::entity_occurs (sos_Cursor c)
  183. // **************************************************************************
  184. {  T_PROC ("sos_Object_Bag::entity_occurs");
  185.    TT (agg_H, T_ENTER);
  186.  
  187.    sos_Int no_of_entries = self.get_m().get_info (c);
  188.  
  189.    TT (agg_H, T_LEAVE);
  190.    return no_of_entries;
  191. } // ** sos_Object_Bag::entity_occurs (sos_Cursor)
  192.  
  193. // **************************************************************************
  194. sos_Bool sos_Object_Bag::to_diff_succ (sos_Cursor c, Index steps)
  195. // **************************************************************************
  196. {  T_PROC ("sos_Object_Bag::to_diff_succ");
  197.    TT (agg_H, T_ENTER);
  198.  
  199.    sos_Object_sos_Int_Mapping m = self.get_m();
  200.    err_assert (c.defined_for (m), "sos_Object_Bag:to_diff_succ");
  201.    err_assert (self.is_valid (c),"sos_Object_Bag:to_diff_succ");   
  202.       
  203.    sos_Bag_node bn = sos_Bag_node::make (c.get_current());
  204.    sos_Bool valid = m.to_succ (c, steps);
  205.    if (valid)
  206.    {  bn.set_tag_no(1);
  207.       bn.set_tag_max (m.get_info (c));
  208.    }
  209.    
  210.    TT (agg_H, T_LEAVE);
  211.    return valid;
  212. } // ** sos_Object_Bag::to_diff_succ **
  213.  
  214. // **************************************************************************
  215. sos_Bool sos_Object_Bag::to_diff_pred (sos_Cursor c, Index steps)
  216. // **************************************************************************
  217. {  T_PROC ("sos_Object_Bag::to_diff_pred");
  218.    TT (agg_H, T_ENTER);
  219.  
  220.    sos_Object_sos_Int_Mapping m = self.get_m();
  221.    err_assert (c.defined_for (m), "sos_Object_Bag:to_diff_pred");
  222.    err_assert (self.is_valid (c),"sos_Object_Bag:to_diff_pred");   
  223.       
  224.    sos_Bag_node bn = sos_Bag_node::make (c.get_current());
  225.    sos_Bool valid = m.to_pred (c, steps);
  226.    if (valid)
  227.    {  sos_Int max = m.get_info (c);
  228.       bn.set_tag_no (max);
  229.       bn.set_tag_max (m.get_info (c));
  230.    }
  231.  
  232.    TT (agg_H, T_LEAVE);
  233.    return valid;
  234. } // ** sos_Object_Bag::to_diff_pred **
  235.  
  236. // **************************************************************************
  237. void sos_Object_Bag::eliminate (sos_Object o)
  238. // **************************************************************************
  239. // loescht alle Vorkommen von o
  240. {
  241.    T_PROC ("sos_Object_Bag::eliminate");
  242.    TT (agg_H, T_ENTER);
  243.  
  244.    sos_Object_sos_Int_Mapping m = self.get_m();
  245.    sos_Int no_of_entries = 0;
  246.  
  247.    if (m.is_key (o))
  248.    {  no_of_entries = m[o];
  249.       m.remove (o);
  250.       self.set_cardinality (self.get_cardinality() - no_of_entries);
  251.    }
  252.  
  253.    TT (agg_H, T_LEAVE);
  254. } // ** sos_Object_Bag::eliminate **
  255.  
  256. // **************************************************************************
  257. sos_Int sos_Object_Bag::occurrences (sos_Object o)
  258. // **************************************************************************
  259. { 
  260.    T_PROC ("sos_Object_Bag::occurrences");
  261.    TT (agg_H, T_ENTER);
  262.  
  263.    sos_Object_sos_Int_Mapping m = self.get_m();
  264.    sos_Int no_of_entries = 0;
  265.  
  266.    if (m.is_key (o))
  267.       no_of_entries = m[o];
  268.  
  269.    TT (agg_H, T_LEAVE);
  270.    return no_of_entries;
  271. } // ** sos_Object_Bag::occurrences (sos_Object)
  272.  
  273. // **************************************************************************
  274. sos_Int sos_Object_Bag::insert (sos_Object o)
  275. // **************************************************************************
  276. // fuege das Objekt o in das Bag ein, es wird die Anzahl der danach (!) im
  277. // Bag vorhandenen Exemplare geliefert.
  278. {
  279.    T_PROC ("sos_Object_Bag::insert");
  280.    TT (agg_H, T_ENTER);
  281.  
  282.    sos_Object_sos_Int_Mapping m = self.get_m();
  283.    sos_Int no_of_entries = 1;
  284.  
  285.    // hole die Abbildung von o, um herauszufinden, wieviel Objekte o
  286.    // schon vorhanden sind
  287.  
  288.    // Der Offset wird sos_Interpretiert als die Anzahl der Objekte o, die schon
  289.    // vorhanden sind.
  290.    if (m.is_key (o))
  291.       no_of_entries = m[o]+1;
  292.  
  293.    m.insert (o, no_of_entries); // ueberschreibe altes o
  294.  
  295.    self.set_cardinality (self.get_cardinality()+1);
  296.    TT (agg_H, T_LEAVE);
  297.    return no_of_entries;
  298. } // ** sos_Object_Bag::insert **
  299.  
  300. // **************************************************************************
  301. sos_Int sos_Object_Bag::remove (sos_Object o)
  302. // **************************************************************************
  303. // loesche ein Objekt o, es wird die Anzahl der Objekte, die 
  304. // vorher (!) im bag waren, zurueckgeliefert
  305. {
  306.    T_PROC ("sos_Object_Bag::remove");
  307.    TT (agg_H, T_ENTER);
  308.  
  309.    sos_Object_sos_Int_Mapping m = self.get_m();
  310.    sos_Int no_of_entries = 0;
  311.  
  312.    if (m.is_key (o))
  313.    {  no_of_entries = m[o];
  314.       if (no_of_entries == 1)
  315.      m.remove (o);
  316.       else
  317.          m.insert (o, no_of_entries-1); 
  318.  
  319.       self.set_cardinality (self.get_cardinality() - 1);
  320.    }
  321.  
  322.    TT (agg_H, T_LEAVE);
  323.    return no_of_entries;
  324. } // ** remove **
  325.  
  326.  
  327. // **************************************************************************
  328. void sos_Object_Bag::operator+= (sos_Object_Bag aset)
  329. // **************************************************************************
  330. // Nach A += B wurden alle Elemente in B zu A aufaddiert
  331. {
  332.    T_PROC ("sos_Object_Bag::operator+=");
  333.    TT (agg_H, T_ENTER);
  334.  
  335.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  336.    sos_Object_sos_Int_Mapping aset_m = aset.get_m();
  337.    sos_Cursor cur = aset_m.open_cursor ();
  338.    for (;aset_m.is_valid (cur);)
  339.    {
  340.       sos_Object o = aset_m.get_key (cur);
  341.       if (aset_m.is_valid (cur) == TRUE)
  342.          aset_m.to_succ (cur);
  343.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  344.       sos_Int aset_entries = self.get_no_of_elements (aset_m, o);
  345.       sos_Int add=self.set_no_of_elements (this_m, o, 
  346.                        this_entries, this_entries+aset_entries);
  347.       self.set_cardinality (self.get_cardinality()+add);
  348.    } // for
  349.    aset_m.close_cursor (cur);
  350.    TT (agg_H, T_LEAVE);
  351. } // ** _sos_Object_Bag:;operator+= **
  352.  
  353. // **************************************************************************
  354. void sos_Object_Bag::operator-= (sos_Object_Bag aset)
  355. // **************************************************************************
  356. // Nach A -= B wurden aus A alle Elemente, die in B sind, entfernt
  357. {  T_PROC ("sos_Object_Bag::operator-=");
  358.    TT (agg_H, T_ENTER);
  359.  
  360.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  361.    sos_Object_sos_Int_Mapping aset_m = aset.get_m();
  362.  
  363.    sos_Cursor cur = aset_m.open_cursor();
  364.  
  365.    for (;(aset_m.is_valid (cur));)
  366.    {  sos_Object o = aset_m.get_key (cur);
  367.       if (aset_m.is_valid (cur))
  368.          aset_m.to_succ (cur);
  369.  
  370.       // Wie oft gibt`s das Element ?
  371.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  372.       sos_Int aset_entries = self.get_no_of_elements (aset_m, o);
  373.       sos_Int new_entries = this_entries-aset_entries;
  374.       if (new_entries < 0)
  375.          new_entries = 0;
  376.       
  377.       sos_Int add = self.set_no_of_elements (this_m, o, this_entries, new_entries);
  378.  
  379.       self.set_cardinality (self.get_cardinality()+add);
  380.    } // for
  381.    aset_m.close_cursor (cur);
  382.    TT (agg_H, T_LEAVE);
  383. } // ** _sos_Object_Bag:;operator-= **
  384.  
  385. // **************************************************************************
  386. void sos_Object_Bag::operator*= (sos_Object_Bag aset)
  387. // **************************************************************************
  388. // Liefert die Schnittmenge von A und B,
  389. // Also entferne aus self alle Elemente, die nicht in aset sind
  390. {  
  391.    T_PROC ("sos_Object_Bag::operator*=");
  392.    TT (agg_H, T_ENTER);
  393.  
  394.  
  395.    sos_Object_sos_Int_Mapping aset_m = aset.get_m();
  396.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  397.    sos_Cursor cur = this_m.open_cursor();
  398.    sos_Bool cur_valid = this_m.is_valid (cur); 
  399.    sos_Int length = self.get_cardinality();
  400.    for (;(cur_valid);)
  401.    {  sos_Object o = this_m.get_key (cur);
  402.       // erhoehe gleich den Cursor, da das sos_Object in set_no_of_element 
  403.       // eventuel geloescht wird. Wuerde dann to_succ aufgerufen, 
  404.       // gaebe es den altbekannten SEGV
  405.       if (cur_valid)
  406.          cur_valid = this_m.to_succ (cur);
  407.  
  408.       // Wieviel Auspraegungen von diesem Element gibt es ?
  409.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  410.       sos_Int aset_entries = self.get_no_of_elements (aset_m, o);
  411.       // Die neue Anzahl ist das Minimum der beiden
  412.       sos_Int new_entries = this_entries;
  413.       if (this_entries > aset_entries )
  414.          new_entries = aset_entries;
  415.  
  416.       sos_Int add = self.set_no_of_elements (this_m, o, this_entries, new_entries);
  417.       
  418.       length += add;
  419.    } // for 
  420.    self.set_cardinality (length);
  421.    this_m.close_cursor (cur);
  422.    TT (agg_H, T_LEAVE);
  423. } // ** sos_Object_Bag::operator*= **
  424.  
  425. // **************************************************************************
  426. sos_Bool sos_Object_Bag::operator< (sos_Object_Bag aset)
  427. // **************************************************************************
  428. // Liefert TRUE zurueck, wenn jedes Element aus this auch in aset ist
  429. // und aset mindestens ein Element mehr enthaelt
  430. { 
  431.    T_PROC ("sos_Object_Bag::operator<");
  432.    TT (agg_H, T_ENTER);
  433.  
  434.    sos_Object_sos_Int_Mapping aset_m = aset.get_m();
  435.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  436.  
  437.    // pruefe zuerst, ob die Anzahl der Elemente schon ein Ergebnis liefert
  438.    if (self.get_cardinality() >= aset.get_cardinality())
  439.    {
  440.       TT (agg_H, T_LEAVE);
  441.       return FALSE;
  442.    }
  443.    
  444.    // So, ab hier sind in aset mehr Elemente als in this
  445.  
  446.    sos_Cursor cur = this_m.open_cursor();
  447.    for (;this_m.is_valid (cur);this_m.to_succ (cur))
  448.    {  sos_Object o = this_m.get_key (cur);
  449.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  450.       sos_Int aset_entries = self.get_no_of_elements (aset_m, o);
  451.       if (this_entries > aset_entries)
  452.       {
  453.          this_m.close_cursor (cur);
  454.          TT (agg_H, T_LEAVE);
  455.          return FALSE;
  456.       }
  457.    } // for
  458.    this_m.close_cursor (cur);
  459.  
  460.    // Hier angekommen, ist this < aset
  461.    TT (agg_H, T_LEAVE);
  462.    return TRUE;
  463. } // ** sos_Object_Bag::operator< **
  464.  
  465. // **************************************************************************
  466. sos_Bool sos_Object_Bag::operator<= (sos_Object_Bag aset)
  467. // **************************************************************************
  468. // Liefert TRUE zurueck, wenn jedes Element aus this auch in aset ist
  469. { 
  470.    T_PROC ("sos_Object_Bag::operator<=");
  471.    TT (agg_H, T_ENTER);
  472.  
  473.    sos_Object_sos_Int_Mapping aset_m = aset.get_m();
  474.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  475.  
  476.    // pruefe zuerst, ob die Anzahl der Elemente schon ein Ergebnis liefert
  477.    if (self.get_cardinality() > aset.get_cardinality())
  478.    {  TT (agg_H, T_LEAVE);
  479.       return FALSE;
  480.    }
  481.  
  482.    // So, ab hier sind in aset mindestens soviele Elemente wie in this
  483.    sos_Cursor cur = this_m.open_cursor();
  484.    for (;this_m.is_valid (cur);this_m.to_succ (cur))
  485.    {  sos_Object o = this_m.get_key (cur);
  486.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  487.       sos_Int aset_entries = self.get_no_of_elements (aset_m, o);
  488.       if (this_entries > aset_entries)
  489.       {  this_m.close_cursor (cur);
  490.          TT (agg_H, T_LEAVE);
  491.          return FALSE;
  492.       }
  493.    } // for
  494.    this_m.close_cursor (cur);
  495.    TT (agg_H, T_LEAVE);
  496.    return TRUE;
  497. } // ** sos_Object_Bag::operator<= **
  498.  
  499. // **************************************************************************
  500. sos_Bool sos_Object_Bag::operator> (sos_Object_Bag aset)
  501. { return sos_Bool (aset < self); }
  502. // **************************************************************************
  503.  
  504. // **************************************************************************
  505. sos_Bool sos_Object_Bag::operator>= (sos_Object_Bag aset)
  506. { return sos_Bool (aset <= self); }
  507. // **************************************************************************
  508.  
  509. // **************************************************************************
  510. void sos_Object_Bag::max_union (sos_Object_Bag b)
  511. // **************************************************************************
  512. {  T_PROC ("sos_Object_Bag::max_union");
  513.    TT(agg_H, T_ENTER);
  514.  
  515.    sos_Object_sos_Int_Mapping this_m = self.get_m();
  516.    sos_Object_sos_Int_Mapping b_m    = b.get_m();
  517.    sos_Cursor cur     = b_m.open_cursor ();
  518.    for (;b_m.is_valid (cur);)
  519.    {  sos_Object o;
  520.       o = b_m.get_key (cur);
  521.       b_m.to_succ (cur);
  522.       sos_Int this_entries = self.get_no_of_elements (this_m, o);
  523.       sos_Int b_entries = self.get_no_of_elements (b_m, o);
  524.       if (this_entries < b_entries)
  525.       {  sos_Int add = self.set_no_of_elements (this_m, o, this_entries, b_entries);
  526.          self.set_cardinality (self.get_cardinality()+add);
  527.       }
  528.    } // for
  529.    b_m.close_cursor (cur);
  530.    TT (agg_H, T_LEAVE);
  531. } // ** sos_Object_Bag::max_union **
  532.  
  533. // **************************************************************************
  534. void sos_Object_Bag::local_assign (sos_Object_Bag x, sos_Object o)
  535. // **************************************************************************
  536. {  T_PROC ("sos_Object_Bag::local_assign");
  537.    TT(agg_H, T_ENTER);
  538.  
  539.    sos_Object_Bag y = sos_Object_Bag::make (o);
  540.    x.get_m().assign (y.get_m());
  541.  
  542.    x.set_cardinality (y.get_cardinality());
  543.    TT(agg_H, T_LEAVE);
  544. } // sos_Object_Bag::local_assign
  545.  
  546. // **************************************************************************
  547. sos_Bool sos_Object_Bag::local_equal (sos_Object_Bag x,
  548.                                       sos_Object     o,
  549.                       sos_Eq_kind    eq_kind)
  550. // **************************************************************************
  551. {  T_PROC ("sos_Object_Bag::local_equal");
  552.    TT(agg_H, T_ENTER);
  553.    
  554.    sos_Bool result;
  555.  
  556.    if ((eq_kind EQ EQ_STRONG AND NOT o.has_type (x.type())) OR
  557.        (eq_kind EQ EQ_WEAK   AND NOT o.isa (x.type())))
  558.       result = FALSE;
  559.    else
  560.    {  sos_Object_Bag y = sos_Object_Bag::make (o);
  561.       sos_Object_sos_Int_Mapping x_m = x.get_m();
  562.       sos_Object_sos_Int_Mapping y_m = y.get_m();
  563.       if (x.get_cardinality() != y.get_cardinality())
  564.      result = FALSE;
  565.       else
  566.       {  result = TRUE;
  567.      agg_iterate_association (x_m, sos_Object key, sos_Int x_entries)
  568.      {  if (x_entries != y.get_no_of_elements (y_m, key))
  569.         {  result = FALSE;
  570.            break;
  571.         }  
  572.      }
  573.      agg_iterate_association_end (x_m, key, x_entries);
  574.       }
  575.    }
  576.  
  577.    TT(agg_H, T_LEAVE;TB(result));
  578.  
  579.    return result;
  580. } // sos_Object_Bag::local_equal
  581.  
  582. // **************************************************************************
  583. sos_Int sos_Object_Bag::local_hash_value (sos_Object_Bag)
  584. // **************************************************************************
  585. {  T_PROC ("sos_Object_Bag::local_hash_value");
  586.    TT(agg_H, T_ENTER);
  587.    
  588.    sos_Int result = 0;
  589.  
  590.    TT(agg_H, T_LEAVE);
  591.  
  592.    return result;
  593. } // sos_Object_Bag::local_hash_value
  594.  
  595. // **************************************************************************
  596. sos_Bool sos_Object_Bag::is_element (sos_Object o)
  597. // **************************************************************************
  598. {  T_PROC ("sos_Object_Bag::is_element");
  599.    TT (agg_H, T_ENTER);
  600.  
  601.    sos_Bool result = self.get_m().is_key (o);
  602.  
  603.    TT (agg_H, T_LEAVE);
  604.    return result;
  605. } // ** sos_Object_Bag::is_element (sos_Object)
  606.  
  607. // **************************************************************************
  608. sos_Object sos_Object_Bag::get (sos_Cursor c)
  609. // **************************************************************************
  610. {  T_PROC ("sos_Object_Bag::get");
  611.    TT (agg_H, T_ENTER);
  612.  
  613.    err_assert (c.defined_for (self.get_m()), "sos_Object_Bag:get");
  614.    err_assert (self.is_valid (c),"sos_Object_Bag:get");   
  615.  
  616.    sos_Object o = sos_Bag_node::make (c.get_current()).get_key_val();
  617.     
  618.    TT (agg_H, T_LEAVE);
  619.    return o;
  620. } // ** sos_Object_Bag::get **
  621.  
  622. // **************************************************************************
  623. void sos_Object_Bag::remove_at (sos_Cursor c)
  624. // **************************************************************************
  625. {  T_PROC ("sos_Object_Bag::remove_at");
  626.    TT(agg_H, T_ENTER);
  627.  
  628.    err_assert (c.defined_for (self.get_m()), "sos_Object_Bag:remove_at");
  629.    err_assert (self.is_valid (c),"sos_Object_Bag:remove_at");   
  630.  
  631.    sos_Object entity = self.get (c);
  632.    if (self.get_list_cursor())
  633.       self.to_succ (c,1);
  634.    else
  635.       {  sos_Bag_node bn = sos_Bag_node::make (c.get_current());
  636.          sos_Object my_no_object = self.get_m();
  637.          bn.set_key_val (my_no_object);
  638.       }
  639.    self.remove (entity);
  640.  
  641.    TT(agg_H, T_LEAVE);
  642. } // sos_Object_Bag::remove_at
  643.  
  644. // **************************************************************************
  645. sos_Int sos_Object_Bag::card ()
  646. // **************************************************************************
  647. {
  648.    T_PROC ("sos_Object_Bag::card");
  649.    TT (agg_H, T_ENTER);
  650.  
  651.    sos_Int crd = self.get_cardinality();
  652.  
  653.    TT (agg_H, T_LEAVE; TI(crd));
  654.    return crd;
  655. } // ** card **
  656.  
  657. // **************************************************************************
  658. void sos_Object_Bag::clear()
  659. // **************************************************************************
  660. {  T_PROC ("sos_Object_Bag::clear");
  661.    TT (agg_H, T_ENTER);
  662.    
  663.    self.get_m().clear();
  664.    self.set_cardinality(0);
  665.  
  666.    TT (agg_H, T_LEAVE);
  667. } // ** clear
  668.  
  669. // **************************************************************************
  670. sos_Cursor sos_Object_Bag::open_cursor (sos_Container Cursor_ct)
  671. // **************************************************************************
  672. {  sos_Container ct = self.container();
  673.    sos_Object_sos_Int_Mapping m = self.get_m();
  674.    sos_Cursor c = sos_Cursor::create(Cursor_ct, m);
  675.    sos_Bag_node bn = sos_Bag_node::create(Cursor_ct);
  676.  
  677.    c.set_current (bn);
  678.    m.to_first (c);
  679.    if (self.is_valid (c))
  680.    {  bn.set_tag_no(1);
  681.       bn.set_tag_max (m.get_info (c));
  682.    }
  683.  
  684.    return c;
  685. } // sos_Object_Bag::open_cursor
  686.  
  687. // **************************************************************************
  688. void sos_Object_Bag::close_cursor (sos_Cursor c)
  689. // **************************************************************************
  690. {  
  691.    c.get_current().destroy();
  692.    c.destroy();
  693. } // sos_Object_Bag::close_cursor
  694.  
  695. // **************************************************************************
  696. sos_Cursor sos_Object_Bag::duplicate (sos_Cursor c)
  697. // **************************************************************************
  698. {  sos_Container Cursor_ct = c.container();
  699.    sos_Bag_node  bn        = sos_Bag_node::make (c.get_current());
  700.    sos_Cursor dup_c        = sos_Cursor::create(Cursor_ct, self.get_m());
  701.    sos_Bag_node dup_bn     = sos_Bag_node::create(Cursor_ct);
  702.  
  703.    dup_c.set_current (dup_bn);
  704.    dup_bn.set_key_val (bn.get_key_val());
  705.    dup_bn.set_tag_no (bn.get_tag_no());
  706.    dup_bn.set_tag_max (bn.get_tag_max());
  707.    return dup_c;
  708. } // sos_Object_Bag::duplicate
  709.  
  710. // **************************************************************************
  711. sos_Bool sos_Object_Bag::is_valid (sos_Cursor c)
  712. // ************************************************************************** 
  713. {  sos_Bool valid = self.get_m().is_valid (c);
  714.    return valid;
  715. } // ** is_valid **
  716.  
  717. // **************************************************************************
  718. sos_Bool sos_Object_Bag::to_first (sos_Cursor c)
  719. // **************************************************************************
  720. {  sos_Object_sos_Int_Mapping m = self.get_m();
  721.    sos_Bag_node  bn        = sos_Bag_node::make (c.get_current());
  722.    sos_Container Cursor_ct = c.container();
  723.  
  724.    m.to_first (c);
  725.    if (m.is_valid (c))
  726.    { bn.set_tag_no(1);
  727.      bn.set_tag_max (m.get_info (c));
  728.    }
  729.  
  730.    return m.is_valid (c);
  731. } // sos_Object_Bag::to_first
  732.  
  733. // **************************************************************************
  734. sos_Bool sos_Object_Bag::to_last (sos_Cursor c)
  735. // **************************************************************************
  736. {  sos_Object_sos_Int_Mapping m = self.get_m();
  737.    sos_Bag_node  bn = sos_Bag_node::make (c.get_current());
  738.    sos_Container Cursor_ct = c.container();
  739.  
  740.    m.to_last (c);
  741.    if (m.is_valid (c))
  742.    {   sos_Int no = m.get_info (c);
  743.        bn.set_tag_no (no);
  744.        bn.set_tag_max (no);
  745.    }
  746.  
  747.    return m.is_valid (c);
  748. } // sos_Object_Bag::to_last
  749.  
  750. // **************************************************************************
  751. sos_Bool sos_Object_Bag::to_succ (sos_Cursor c, Index steps)
  752. // **************************************************************************
  753. {  T_PROC ("sos_Object_Bag::to_succ");
  754.    TT (agg_H, T_ENTER);
  755.  
  756.    err_assert (c.defined_for (self.get_m()), "sos_Object_Bag:to_succ");
  757.    err_assert (self.is_valid (c),"sos_Object_Bag:to_succ");   
  758.       
  759.    sos_Bag_node bn = sos_Bag_node::make (c.get_current());
  760.    sos_Object   o;
  761.    sos_Int      no, max;
  762.  
  763.    self.search_succ_pred (bn, steps, o, no, max);
  764.    self.write_current (c, o, no, max);
  765.  
  766.    TT (agg_H, T_LEAVE);
  767.    return self.is_valid (c);
  768. } // ** sos_Object_Bag::to_succ **
  769.  
  770. // **************************************************************************
  771. sos_Bool sos_Object_Bag::to_pred (sos_Cursor c, Index steps)
  772. // **************************************************************************
  773. {  T_PROC ("sos_Object_Bag::to_pred");
  774.    TT (agg_H, T_ENTER);
  775.  
  776.    err_assert (c.defined_for (self.get_m()), "sos_Object_Bag:to_pred");
  777.    err_assert (self.is_valid (c),"sos_Object_Bag:to_pred");   
  778.       
  779.    sos_Bag_node bn = sos_Bag_node::make (c.get_current());
  780.    sos_Object   o;
  781.    sos_Int      no, max;
  782.  
  783.    self.search_succ_pred (bn,-steps, o, no, max);
  784.    self.write_current (c, o, no, max);
  785.    
  786.    TT (agg_H, T_LEAVE);
  787.    return self.is_valid (c);
  788. } // ** sos_Object_Bag::to_pred **
  789.